package work.droit.data.merge;

import java.io.File;
import java.sql.Connection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import work.droit.data.Categorie;
import work.droit.data.Champs.CategorieChamp;
import work.droit.data.Champs.DefinitionChamp;
import work.droit.data.Champs.FicheChamp;
import work.droit.data.Champs.JurisprudenceChamp;
import work.droit.data.Champs.QuestionChamp;
import work.droit.data.Definition;
import work.droit.data.Fiche;
import work.droit.data.Jurisprudence;
import work.droit.data.Question;
import work.droit.gui.ApiController;
import work.util.data.HsqlDb.HsqlDbUtil;
import work.util.data.io.ManipFile;
import work.util.data.io.ZipExtractor;
import work.util.data.table.Tables.Record;
import work.util.editor.EditorLauncher;

public class ImportBase
{
	private boolean	eraseFile	= false;

	public ImportBase(boolean eraseFile)
	{
		this.eraseFile = eraseFile;
	}

	public void merge(String selected)
	{
		File fileDestDir = new File("tmp");
		fileDestDir.mkdirs();

		new ZipExtractor(selected, fileDestDir.getName());

		Connection tmpCon = HsqlDbUtil.createConnection("tmp/database");

		Categorie cat = new Categorie();
		cat.setChamp(Categorie.name, "");
		cat.setConnection(tmpCon);

		Map<Integer, Integer> mapIdCat = new HashMap<Integer, Integer>();

		// creation et association des categories avec l'existant
		List<Record<CategorieChamp>> listCat = cat.searchListRecords(Categorie.name, Categorie.name);
		for (Record<CategorieChamp> rec : listCat)
		{
			Categorie cTmp = (Categorie) rec;

			Categorie c = new Categorie();
			c.setChamp(Categorie.name, cTmp.getValue(Categorie.name));

			if (c.exist(Categorie.name))
			{
				c.load(Categorie.name);
			}
			else
			{
				c.initialiseNewKey();
				c.insert();
			}

			mapIdCat.put((Integer) cTmp.getValue(Categorie.id), (Integer) c.getValue(Categorie.id));
		}
		// reassociation des parents
		for (Record<CategorieChamp> rec : listCat)
		{
			Categorie cTmp = (Categorie) rec;
			Categorie c = new Categorie();
			c.setChamp(Categorie.name, cTmp.getValue(Categorie.name));
			c.load(Categorie.name);
			c.setChamp(Categorie.parentId, mapIdCat.get(cTmp.getValue(Categorie.parentId)));
			c.update();
		}

		Fiche fic = new Fiche();
		fic.setChamp(Fiche.name, "");
		fic.setConnection(tmpCon);

		Map<Integer, Integer> mapIdFic = new HashMap<Integer, Integer>();

		// creation et association des fiches avec l'existant
		List<Record<FicheChamp>> listFic = fic.searchListRecords(Fiche.name, Fiche.name);
		for (Record<FicheChamp> ref : listFic)
		{
			Fiche fTmp = (Fiche) ref;

			Fiche f = new Fiche();
			f.setChamp(Fiche.name, fTmp.getValue(Fiche.name));

			boolean newFiche = false;

			if (f.exist(Fiche.name))
			{
				f.load(Fiche.name);
				f.setChamp(Fiche.categorie, mapIdCat.get(fTmp.getValue(Fiche.categorie)));
				f.update();
			}
			else
			{
				f.initialiseNewKey();
				f.setChamp(Fiche.categorie, mapIdCat.get(fTmp.getValue(Fiche.categorie)));
				f.insert();
				newFiche = true;
			}
			if (newFiche || eraseFile)
			{
				String contentTmp = ManipFile.getContent("tmp/" + fTmp.getValue(Fiche.id) + "f" + EditorLauncher.FILE_EXTENSION);
				ManipFile.saveContent(ApiController.pathDocument + f.getValue(Fiche.id) + "f" + EditorLauncher.FILE_EXTENSION, contentTmp);
			}

			mapIdFic.put((Integer) fTmp.getValue(Fiche.id), (Integer) f.getValue(Fiche.id));
		}

		Jurisprudence jur = new Jurisprudence();
		jur.setChamp(Jurisprudence.name, "");
		jur.setConnection(tmpCon);

		Map<Integer, Integer> mapIdJur = new HashMap<Integer, Integer>();

		// creation et association des jurisprudence avec l'existant
		List<Record<JurisprudenceChamp>> listJur = jur.searchListRecords(Jurisprudence.name, Jurisprudence.name);
		for (Record<JurisprudenceChamp> rej : listJur)
		{
			Jurisprudence jTmp = (Jurisprudence) rej;

			Jurisprudence j = new Jurisprudence();
			j.setChamp(Jurisprudence.name, jTmp.getValue(Jurisprudence.name));

			boolean newFiche = false;

			if (j.exist(Jurisprudence.name))
			{
				j.load(Jurisprudence.name);
				j.setChamp(Jurisprudence.fiche, mapIdFic.get(jTmp.getValue(Jurisprudence.fiche)));
				j.update();
			}
			else
			{
				j.initialiseNewKey();
				j.setChamp(Jurisprudence.fiche, mapIdFic.get(jTmp.getValue(Jurisprudence.fiche)));
				j.insert();
				newFiche = true;
			}
			if (newFiche || eraseFile)
			{
				String contentTmp = ManipFile.getContent("tmp/" + jTmp.getValue(Jurisprudence.id) + "j" + EditorLauncher.FILE_EXTENSION);
				ManipFile.saveContent(ApiController.pathDocument + j.getValue(Jurisprudence.id) + "j" + EditorLauncher.FILE_EXTENSION, contentTmp);
			}

			mapIdJur.put((Integer) jTmp.getValue(Jurisprudence.id), (Integer) j.getValue(Jurisprudence.id));
		}

		Question que = new Question();
		que.setChamp(Question.name, "");
		que.setConnection(tmpCon);

		Map<Integer, Integer> mapIdQue = new HashMap<Integer, Integer>();

		// creation et association des questions avec l'existant
		List<Record<QuestionChamp>> listQue = que.searchListRecords(Question.name, Question.name);
		for (Record<QuestionChamp> req : listQue)
		{
			Question qTmp = (Question) req;

			Question q = new Question();
			q.setChamp(Question.name, qTmp.getValue(Question.name));

			boolean newFiche = false;

			if (q.exist(Question.name))
			{
				q.load(Question.name);
				q.setChamp(Question.fiche, mapIdFic.get(qTmp.getValue(Question.fiche)));
				q.update();
			}
			else
			{
				q.initialiseNewKey();
				q.setChamp(Question.fiche, mapIdFic.get(qTmp.getValue(Question.fiche)));
				q.insert();
				newFiche = true;
			}
			if (newFiche || eraseFile)
			{
				String contentTmp = ManipFile.getContent("tmp/" + qTmp.getValue(Question.id) + "q.txt");
				ManipFile.saveContent(ApiController.pathDocument + q.getValue(Question.id) + "q.txt", contentTmp);
				contentTmp = ManipFile.getContent("tmp/" + qTmp.getValue(Question.id) + "r.txt");
				ManipFile.saveContent(ApiController.pathDocument + q.getValue(Question.id) + "r.txt", contentTmp);
			}

			mapIdQue.put((Integer) qTmp.getValue(Question.id), (Integer) q.getValue(Question.id));
		}

		Definition def = new Definition();
		def.setChamp(Definition.mot, "");
		def.setConnection(tmpCon);

		Map<Integer, Integer> mapIdDef = new HashMap<Integer, Integer>();

		// creation et association des definitions avec l'existant
		List<Record<DefinitionChamp>> listDef = def.searchListRecords(Definition.mot, Definition.mot);
		for (Record<DefinitionChamp> red : listDef)
		{
			Definition dTmp = (Definition) red;

			Definition d = new Definition();
			d.setChamp(Definition.mot, dTmp.getValue(Definition.mot));

			boolean newFiche = false;

			if (d.exist(Definition.mot))
			{
				d.load(Definition.mot);
				d.update();
			}
			else
			{
				d.initialiseNewKey();
				d.insert();
				newFiche = true;
			}
			if (newFiche || eraseFile)
			{
				String contentTmp = ManipFile.getContent("tmp" + dTmp.getValue(Definition.id) + "d.txt");
				ManipFile.saveContent(ApiController.pathDocument + d.getValue(Definition.id) + "d.txt", contentTmp);
			}

			mapIdDef.put((Integer) dTmp.getValue(Definition.id), (Integer) d.getValue(Definition.id));
		}
		
		HsqlDbUtil.disconnect(tmpCon);

		ManipFile.deleteDirectory(fileDestDir);
	}
}
